/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Attributes.h.zapt

#pragma once

#include <app/ConcreteAttributePath.h>
#include <app/data-model/DecodableList.h>
#include <app/data-model/List.h>
#include <app/data-model/Nullable.h>
#include <app/util/basic-types.h>
#include <lib/core/TLV.h>
#include <lib/support/BitMask.h>

#include <clusters/shared/Attributes.h>
#include <clusters/shared/Enums.h>
#include <clusters/shared/Structs.h>

#include <clusters/UnitTesting/AttributeIds.h>
#include <clusters/UnitTesting/ClusterId.h>
#include <clusters/UnitTesting/Enums.h>
#include <clusters/UnitTesting/Structs.h>

namespace chip
{
namespace app
{
	namespace Clusters
	{
		namespace UnitTesting
		{
			namespace Attributes
			{

				namespace Boolean
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Boolean::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Boolean
				namespace Bitmap8
				{
					struct TypeInfo {
						using Type =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;
						using DecodableType =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;
						using DecodableArgType =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Bitmap8::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Bitmap8
				namespace Bitmap16
				{
					struct TypeInfo {
						using Type =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;
						using DecodableType =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;
						using DecodableArgType =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Bitmap16::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Bitmap16
				namespace Bitmap32
				{
					struct TypeInfo {
						using Type =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;
						using DecodableType =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;
						using DecodableArgType =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Bitmap32::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Bitmap32
				namespace Bitmap64
				{
					struct TypeInfo {
						using Type =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;
						using DecodableType =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;
						using DecodableArgType =
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Bitmap64::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Bitmap64
				namespace Int8u
				{
					struct TypeInfo {
						using Type = uint8_t;
						using DecodableType = uint8_t;
						using DecodableArgType = uint8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int8u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int8u
				namespace Int16u
				{
					struct TypeInfo {
						using Type = uint16_t;
						using DecodableType = uint16_t;
						using DecodableArgType = uint16_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int16u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int16u
				namespace Int24u
				{
					struct TypeInfo {
						using Type = uint32_t;
						using DecodableType = uint32_t;
						using DecodableArgType = uint32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int24u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int24u
				namespace Int32u
				{
					struct TypeInfo {
						using Type = uint32_t;
						using DecodableType = uint32_t;
						using DecodableArgType = uint32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int32u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int32u
				namespace Int40u
				{
					struct TypeInfo {
						using Type = uint64_t;
						using DecodableType = uint64_t;
						using DecodableArgType = uint64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int40u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int40u
				namespace Int48u
				{
					struct TypeInfo {
						using Type = uint64_t;
						using DecodableType = uint64_t;
						using DecodableArgType = uint64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int48u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int48u
				namespace Int56u
				{
					struct TypeInfo {
						using Type = uint64_t;
						using DecodableType = uint64_t;
						using DecodableArgType = uint64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int56u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int56u
				namespace Int64u
				{
					struct TypeInfo {
						using Type = uint64_t;
						using DecodableType = uint64_t;
						using DecodableArgType = uint64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int64u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int64u
				namespace Int8s
				{
					struct TypeInfo {
						using Type = int8_t;
						using DecodableType = int8_t;
						using DecodableArgType = int8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int8s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int8s
				namespace Int16s
				{
					struct TypeInfo {
						using Type = int16_t;
						using DecodableType = int16_t;
						using DecodableArgType = int16_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int16s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int16s
				namespace Int24s
				{
					struct TypeInfo {
						using Type = int32_t;
						using DecodableType = int32_t;
						using DecodableArgType = int32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int24s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int24s
				namespace Int32s
				{
					struct TypeInfo {
						using Type = int32_t;
						using DecodableType = int32_t;
						using DecodableArgType = int32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int32s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int32s
				namespace Int40s
				{
					struct TypeInfo {
						using Type = int64_t;
						using DecodableType = int64_t;
						using DecodableArgType = int64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int40s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int40s
				namespace Int48s
				{
					struct TypeInfo {
						using Type = int64_t;
						using DecodableType = int64_t;
						using DecodableArgType = int64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int48s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int48s
				namespace Int56s
				{
					struct TypeInfo {
						using Type = int64_t;
						using DecodableType = int64_t;
						using DecodableArgType = int64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int56s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int56s
				namespace Int64s
				{
					struct TypeInfo {
						using Type = int64_t;
						using DecodableType = int64_t;
						using DecodableArgType = int64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Int64s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Int64s
				namespace Enum8
				{
					struct TypeInfo {
						using Type = uint8_t;
						using DecodableType = uint8_t;
						using DecodableArgType = uint8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Enum8::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Enum8
				namespace Enum16
				{
					struct TypeInfo {
						using Type = uint16_t;
						using DecodableType = uint16_t;
						using DecodableArgType = uint16_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Enum16::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Enum16
				namespace FloatSingle
				{
					struct TypeInfo {
						using Type = float;
						using DecodableType = float;
						using DecodableArgType = float;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::FloatSingle::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace FloatSingle
				namespace FloatDouble
				{
					struct TypeInfo {
						using Type = double;
						using DecodableType = double;
						using DecodableArgType = double;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::FloatDouble::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace FloatDouble
				namespace OctetString
				{
					struct TypeInfo {
						using Type = chip::ByteSpan;
						using DecodableType = chip::ByteSpan;
						using DecodableArgType = chip::ByteSpan;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::OctetString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 10; }
					};
				} // namespace OctetString
				namespace ListInt8u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<const uint8_t>;
						using DecodableType = chip::app::DataModel::DecodableList<uint8_t>;
						using DecodableArgType =
							const chip::app::DataModel::DecodableList<uint8_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ListInt8u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ListInt8u
				namespace ListOctetString
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<const chip::ByteSpan>;
						using DecodableType =
							chip::app::DataModel::DecodableList<chip::ByteSpan>;
						using DecodableArgType =
							const chip::app::DataModel::DecodableList<chip::ByteSpan> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ListOctetString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ListOctetString
				namespace ListStructOctetString
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<
							const chip::app::Clusters::UnitTesting::Structs::
								TestListStructOctet::Type>;
						using DecodableType = chip::app::DataModel::DecodableList<
							chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::
								DecodableType>;
						using DecodableArgType = const chip::app::DataModel::DecodableList<
							chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::
								DecodableType> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ListStructOctetString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ListStructOctetString
				namespace LongOctetString
				{
					struct TypeInfo {
						using Type = chip::ByteSpan;
						using DecodableType = chip::ByteSpan;
						using DecodableArgType = chip::ByteSpan;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::LongOctetString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 1000; }
					};
				} // namespace LongOctetString
				namespace CharString
				{
					struct TypeInfo {
						using Type = chip::CharSpan;
						using DecodableType = chip::CharSpan;
						using DecodableArgType = chip::CharSpan;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::CharString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 10; }
					};
				} // namespace CharString
				namespace LongCharString
				{
					struct TypeInfo {
						using Type = chip::CharSpan;
						using DecodableType = chip::CharSpan;
						using DecodableArgType = chip::CharSpan;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::LongCharString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 1000; }
					};
				} // namespace LongCharString
				namespace EpochUs
				{
					struct TypeInfo {
						using Type = uint64_t;
						using DecodableType = uint64_t;
						using DecodableArgType = uint64_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::EpochUs::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace EpochUs
				namespace EpochS
				{
					struct TypeInfo {
						using Type = uint32_t;
						using DecodableType = uint32_t;
						using DecodableArgType = uint32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::EpochS::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace EpochS
				namespace VendorId
				{
					struct TypeInfo {
						using Type = chip::VendorId;
						using DecodableType = chip::VendorId;
						using DecodableArgType = chip::VendorId;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::VendorId::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace VendorId
				namespace ListNullablesAndOptionalsStruct
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<
							const chip::app::Clusters::UnitTesting::Structs::
								NullablesAndOptionalsStruct::Type>;
						using DecodableType = chip::app::DataModel::DecodableList<
							chip::app::Clusters::UnitTesting::Structs::
								NullablesAndOptionalsStruct::DecodableType>;
						using DecodableArgType = const chip::app::DataModel::DecodableList<
							chip::app::Clusters::UnitTesting::Structs::
								NullablesAndOptionalsStruct::DecodableType> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ListNullablesAndOptionalsStruct::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ListNullablesAndOptionalsStruct
				namespace EnumAttr
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::UnitTesting::SimpleEnum;
						using DecodableType = chip::app::Clusters::UnitTesting::SimpleEnum;
						using DecodableArgType = chip::app::Clusters::UnitTesting::SimpleEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::EnumAttr::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace EnumAttr
				namespace StructAttr
				{
					struct TypeInfo {
						using Type =
							chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type;
						using DecodableType = chip::app::Clusters::UnitTesting::Structs::
							SimpleStruct::DecodableType;
						using DecodableArgType = const chip::app::Clusters::UnitTesting::
							Structs::SimpleStruct::DecodableType &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::StructAttr::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace StructAttr
				namespace RangeRestrictedInt8u
				{
					struct TypeInfo {
						using Type = uint8_t;
						using DecodableType = uint8_t;
						using DecodableArgType = uint8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::RangeRestrictedInt8u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace RangeRestrictedInt8u
				namespace RangeRestrictedInt8s
				{
					struct TypeInfo {
						using Type = int8_t;
						using DecodableType = int8_t;
						using DecodableArgType = int8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::RangeRestrictedInt8s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace RangeRestrictedInt8s
				namespace RangeRestrictedInt16u
				{
					struct TypeInfo {
						using Type = uint16_t;
						using DecodableType = uint16_t;
						using DecodableArgType = uint16_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::RangeRestrictedInt16u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace RangeRestrictedInt16u
				namespace RangeRestrictedInt16s
				{
					struct TypeInfo {
						using Type = int16_t;
						using DecodableType = int16_t;
						using DecodableArgType = int16_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::RangeRestrictedInt16s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace RangeRestrictedInt16s
				namespace ListLongOctetString
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<const chip::ByteSpan>;
						using DecodableType =
							chip::app::DataModel::DecodableList<chip::ByteSpan>;
						using DecodableArgType =
							const chip::app::DataModel::DecodableList<chip::ByteSpan> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ListLongOctetString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ListLongOctetString
				namespace ListFabricScoped
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<
							const chip::app::Clusters::UnitTesting::Structs::
								TestFabricScoped::Type>;
						using DecodableType = chip::app::DataModel::DecodableList<
							chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::
								DecodableType>;
						using DecodableArgType = const chip::app::DataModel::DecodableList<
							chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::
								DecodableType> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ListFabricScoped::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ListFabricScoped
				namespace TimedWriteBoolean
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::TimedWriteBoolean::Id;
						}
						static constexpr bool MustUseTimedWrite() { return true; }
					};
				} // namespace TimedWriteBoolean
				namespace GeneralErrorBoolean
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::GeneralErrorBoolean::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace GeneralErrorBoolean
				namespace ClusterErrorBoolean
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ClusterErrorBoolean::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ClusterErrorBoolean
				namespace GlobalEnum
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::Globals::TestGlobalEnum;
						using DecodableType = chip::app::Clusters::Globals::TestGlobalEnum;
						using DecodableArgType = chip::app::Clusters::Globals::TestGlobalEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::GlobalEnum::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace GlobalEnum
				namespace GlobalStruct
				{
					struct TypeInfo {
						using Type =
							chip::app::Clusters::Globals::Structs::TestGlobalStruct::Type;
						using DecodableType = chip::app::Clusters::Globals::Structs::
							TestGlobalStruct::DecodableType;
						using DecodableArgType = const chip::app::Clusters::Globals::Structs::
							TestGlobalStruct::DecodableType &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::GlobalStruct::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace GlobalStruct
				namespace UnsupportedAttributeRequiringAdminPrivilege
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::UnsupportedAttributeRequiringAdminPrivilege::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace UnsupportedAttributeRequiringAdminPrivilege
				namespace Unsupported
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Unsupported::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Unsupported
				namespace ReadFailureCode
				{
					struct TypeInfo {
						using Type = uint8_t;
						using DecodableType = uint8_t;
						using DecodableArgType = uint8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ReadFailureCode::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ReadFailureCode
				namespace FailureInt32U
				{
					struct TypeInfo {
						using Type = uint32_t;
						using DecodableType = uint32_t;
						using DecodableArgType = uint32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::FailureInt32U::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace FailureInt32U
				namespace NullableBoolean
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<bool>;
						using DecodableType = chip::app::DataModel::Nullable<bool>;
						using DecodableArgType = const chip::app::DataModel::Nullable<bool> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableBoolean::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableBoolean
				namespace NullableBitmap8
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
						using DecodableType = chip::app::DataModel::Nullable<
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>;
						using DecodableArgType = const chip::app::DataModel::Nullable<
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>
							&;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableBitmap8::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableBitmap8
				namespace NullableBitmap16
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<chip::BitMask<
							chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
						using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<
							chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<chip::BitMask<
								chip::app::Clusters::UnitTesting::Bitmap16MaskMap>> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableBitmap16::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableBitmap16
				namespace NullableBitmap32
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<chip::BitMask<
							chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
						using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<
							chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<chip::BitMask<
								chip::app::Clusters::UnitTesting::Bitmap32MaskMap>> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableBitmap32::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableBitmap32
				namespace NullableBitmap64
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<chip::BitMask<
							chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
						using DecodableType = chip::app::DataModel::Nullable<chip::BitMask<
							chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<chip::BitMask<
								chip::app::Clusters::UnitTesting::Bitmap64MaskMap>> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableBitmap64::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableBitmap64
				namespace NullableInt8u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint8_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint8_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt8u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt8u
				namespace NullableInt16u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint16_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint16_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt16u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt16u
				namespace NullableInt24u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt24u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt24u
				namespace NullableInt32u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt32u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt32u
				namespace NullableInt40u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint64_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint64_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt40u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt40u
				namespace NullableInt48u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint64_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint64_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt48u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt48u
				namespace NullableInt56u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint64_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint64_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt56u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt56u
				namespace NullableInt64u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint64_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint64_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint64_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt64u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt64u
				namespace NullableInt8s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int8_t>;
						using DecodableType = chip::app::DataModel::Nullable<int8_t>;
						using DecodableArgType = const chip::app::DataModel::Nullable<int8_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt8s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt8s
				namespace NullableInt16s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int16_t>;
						using DecodableType = chip::app::DataModel::Nullable<int16_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<int16_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt16s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt16s
				namespace NullableInt24s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int32_t>;
						using DecodableType = chip::app::DataModel::Nullable<int32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<int32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt24s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt24s
				namespace NullableInt32s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int32_t>;
						using DecodableType = chip::app::DataModel::Nullable<int32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<int32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt32s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt32s
				namespace NullableInt40s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int64_t>;
						using DecodableType = chip::app::DataModel::Nullable<int64_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<int64_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt40s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt40s
				namespace NullableInt48s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int64_t>;
						using DecodableType = chip::app::DataModel::Nullable<int64_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<int64_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt48s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt48s
				namespace NullableInt56s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int64_t>;
						using DecodableType = chip::app::DataModel::Nullable<int64_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<int64_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt56s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt56s
				namespace NullableInt64s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int64_t>;
						using DecodableType = chip::app::DataModel::Nullable<int64_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<int64_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableInt64s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableInt64s
				namespace NullableEnum8
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint8_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint8_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableEnum8::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableEnum8
				namespace NullableEnum16
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint16_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint16_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableEnum16::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableEnum16
				namespace NullableFloatSingle
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<float>;
						using DecodableType = chip::app::DataModel::Nullable<float>;
						using DecodableArgType = const chip::app::DataModel::Nullable<float> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableFloatSingle::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableFloatSingle
				namespace NullableFloatDouble
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<double>;
						using DecodableType = chip::app::DataModel::Nullable<double>;
						using DecodableArgType = const chip::app::DataModel::Nullable<double> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableFloatDouble::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableFloatDouble
				namespace NullableOctetString
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<chip::ByteSpan>;
						using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<chip::ByteSpan> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableOctetString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 10; }
					};
				} // namespace NullableOctetString
				namespace NullableCharString
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<chip::CharSpan>;
						using DecodableType = chip::app::DataModel::Nullable<chip::CharSpan>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<chip::CharSpan> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableCharString::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 10; }
					};
				} // namespace NullableCharString
				namespace NullableEnumAttr
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<
							chip::app::Clusters::UnitTesting::SimpleEnum>;
						using DecodableType = chip::app::DataModel::Nullable<
							chip::app::Clusters::UnitTesting::SimpleEnum>;
						using DecodableArgType = const chip::app::DataModel::Nullable<
							chip::app::Clusters::UnitTesting::SimpleEnum> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableEnumAttr::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableEnumAttr
				namespace NullableStruct
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<
							chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>;
						using DecodableType = chip::app::DataModel::Nullable<
							chip::app::Clusters::UnitTesting::Structs::SimpleStruct::
								DecodableType>;
						using DecodableArgType = const chip::app::DataModel::Nullable<
							chip::app::Clusters::UnitTesting::Structs::SimpleStruct::
								DecodableType> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableStruct::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableStruct
				namespace NullableRangeRestrictedInt8u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint8_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint8_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableRangeRestrictedInt8u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableRangeRestrictedInt8u
				namespace NullableRangeRestrictedInt8s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int8_t>;
						using DecodableType = chip::app::DataModel::Nullable<int8_t>;
						using DecodableArgType = const chip::app::DataModel::Nullable<int8_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableRangeRestrictedInt8s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableRangeRestrictedInt8s
				namespace NullableRangeRestrictedInt16u
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint16_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint16_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableRangeRestrictedInt16u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableRangeRestrictedInt16u
				namespace NullableRangeRestrictedInt16s
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<int16_t>;
						using DecodableType = chip::app::DataModel::Nullable<int16_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<int16_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableRangeRestrictedInt16s::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableRangeRestrictedInt16s
				namespace WriteOnlyInt8u
				{
					struct TypeInfo {
						using Type = uint8_t;
						using DecodableType = uint8_t;
						using DecodableArgType = uint8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::WriteOnlyInt8u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace WriteOnlyInt8u
				namespace NullableGlobalEnum
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<
							chip::app::Clusters::Globals::TestGlobalEnum>;
						using DecodableType = chip::app::DataModel::Nullable<
							chip::app::Clusters::Globals::TestGlobalEnum>;
						using DecodableArgType = const chip::app::DataModel::Nullable<
							chip::app::Clusters::Globals::TestGlobalEnum> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableGlobalEnum::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableGlobalEnum
				namespace NullableGlobalStruct
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<
							chip::app::Clusters::Globals::Structs::TestGlobalStruct::Type>;
						using DecodableType = chip::app::DataModel::Nullable<
							chip::app::Clusters::Globals::Structs::TestGlobalStruct::
								DecodableType>;
						using DecodableArgType = const chip::app::DataModel::Nullable<
							chip::app::Clusters::Globals::Structs::TestGlobalStruct::
								DecodableType> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::NullableGlobalStruct::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace NullableGlobalStruct
				namespace GeneratedCommandList
				{
					struct TypeInfo
						: public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
					};
				} // namespace GeneratedCommandList
				namespace AcceptedCommandList
				{
					struct TypeInfo
						: public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
					};
				} // namespace AcceptedCommandList
				namespace AttributeList
				{
					struct TypeInfo
						: public Clusters::Globals::Attributes::AttributeList::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
					};
				} // namespace AttributeList
				namespace FeatureMap
				{
					struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
					};
				} // namespace FeatureMap
				namespace ClusterRevision
				{
					struct TypeInfo
						: public Clusters::Globals::Attributes::ClusterRevision::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
					};
				} // namespace ClusterRevision
				namespace MeiInt8u
				{
					struct TypeInfo {
						using Type = uint8_t;
						using DecodableType = uint8_t;
						using DecodableArgType = uint8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::MeiInt8u::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace MeiInt8u

				struct TypeInfo {
					struct DecodableType {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						CHIP_ERROR Decode(TLV::TLVReader &reader,
								  const ConcreteAttributePath &path);

						Attributes::Boolean::TypeInfo::DecodableType boolean =
							static_cast<bool>(0);
						Attributes::Bitmap8::TypeInfo::DecodableType bitmap8 = static_cast<
							chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>(
							0);
						Attributes::Bitmap16::TypeInfo::DecodableType bitmap16 =
							static_cast<chip::BitMask<
								chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>(0);
						Attributes::Bitmap32::TypeInfo::DecodableType bitmap32 =
							static_cast<chip::BitMask<
								chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>(0);
						Attributes::Bitmap64::TypeInfo::DecodableType bitmap64 =
							static_cast<chip::BitMask<
								chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>(0);
						Attributes::Int8u::TypeInfo::DecodableType int8u =
							static_cast<uint8_t>(0);
						Attributes::Int16u::TypeInfo::DecodableType int16u =
							static_cast<uint16_t>(0);
						Attributes::Int24u::TypeInfo::DecodableType int24u =
							static_cast<uint32_t>(0);
						Attributes::Int32u::TypeInfo::DecodableType int32u =
							static_cast<uint32_t>(0);
						Attributes::Int40u::TypeInfo::DecodableType int40u =
							static_cast<uint64_t>(0);
						Attributes::Int48u::TypeInfo::DecodableType int48u =
							static_cast<uint64_t>(0);
						Attributes::Int56u::TypeInfo::DecodableType int56u =
							static_cast<uint64_t>(0);
						Attributes::Int64u::TypeInfo::DecodableType int64u =
							static_cast<uint64_t>(0);
						Attributes::Int8s::TypeInfo::DecodableType int8s =
							static_cast<int8_t>(0);
						Attributes::Int16s::TypeInfo::DecodableType int16s =
							static_cast<int16_t>(0);
						Attributes::Int24s::TypeInfo::DecodableType int24s =
							static_cast<int32_t>(0);
						Attributes::Int32s::TypeInfo::DecodableType int32s =
							static_cast<int32_t>(0);
						Attributes::Int40s::TypeInfo::DecodableType int40s =
							static_cast<int64_t>(0);
						Attributes::Int48s::TypeInfo::DecodableType int48s =
							static_cast<int64_t>(0);
						Attributes::Int56s::TypeInfo::DecodableType int56s =
							static_cast<int64_t>(0);
						Attributes::Int64s::TypeInfo::DecodableType int64s =
							static_cast<int64_t>(0);
						Attributes::Enum8::TypeInfo::DecodableType enum8 =
							static_cast<uint8_t>(0);
						Attributes::Enum16::TypeInfo::DecodableType enum16 =
							static_cast<uint16_t>(0);
						Attributes::FloatSingle::TypeInfo::DecodableType floatSingle =
							static_cast<float>(0);
						Attributes::FloatDouble::TypeInfo::DecodableType floatDouble =
							static_cast<double>(0);
						Attributes::OctetString::TypeInfo::DecodableType octetString;
						Attributes::ListInt8u::TypeInfo::DecodableType listInt8u;
						Attributes::ListOctetString::TypeInfo::DecodableType listOctetString;
						Attributes::ListStructOctetString::TypeInfo::DecodableType
							listStructOctetString;
						Attributes::LongOctetString::TypeInfo::DecodableType longOctetString;
						Attributes::CharString::TypeInfo::DecodableType charString;
						Attributes::LongCharString::TypeInfo::DecodableType longCharString;
						Attributes::EpochUs::TypeInfo::DecodableType epochUs =
							static_cast<uint64_t>(0);
						Attributes::EpochS::TypeInfo::DecodableType epochS =
							static_cast<uint32_t>(0);
						Attributes::VendorId::TypeInfo::DecodableType vendorId =
							static_cast<chip::VendorId>(0);
						Attributes::ListNullablesAndOptionalsStruct::TypeInfo::DecodableType
							listNullablesAndOptionalsStruct;
						Attributes::EnumAttr::TypeInfo::DecodableType enumAttr =
							static_cast<chip::app::Clusters::UnitTesting::SimpleEnum>(0);
						Attributes::StructAttr::TypeInfo::DecodableType structAttr;
						Attributes::RangeRestrictedInt8u::TypeInfo::DecodableType
							rangeRestrictedInt8u = static_cast<uint8_t>(0);
						Attributes::RangeRestrictedInt8s::TypeInfo::DecodableType
							rangeRestrictedInt8s = static_cast<int8_t>(0);
						Attributes::RangeRestrictedInt16u::TypeInfo::DecodableType
							rangeRestrictedInt16u = static_cast<uint16_t>(0);
						Attributes::RangeRestrictedInt16s::TypeInfo::DecodableType
							rangeRestrictedInt16s = static_cast<int16_t>(0);
						Attributes::ListLongOctetString::TypeInfo::DecodableType
							listLongOctetString;
						Attributes::ListFabricScoped::TypeInfo::DecodableType listFabricScoped;
						Attributes::TimedWriteBoolean::TypeInfo::DecodableType
							timedWriteBoolean = static_cast<bool>(0);
						Attributes::GeneralErrorBoolean::TypeInfo::DecodableType
							generalErrorBoolean = static_cast<bool>(0);
						Attributes::ClusterErrorBoolean::TypeInfo::DecodableType
							clusterErrorBoolean = static_cast<bool>(0);
						Attributes::GlobalEnum::TypeInfo::DecodableType globalEnum =
							static_cast<chip::app::Clusters::Globals::TestGlobalEnum>(0);
						Attributes::GlobalStruct::TypeInfo::DecodableType globalStruct;
						Attributes::UnsupportedAttributeRequiringAdminPrivilege::TypeInfo::
							DecodableType unsupportedAttributeRequiringAdminPrivilege =
								static_cast<bool>(0);
						Attributes::Unsupported::TypeInfo::DecodableType unsupported =
							static_cast<bool>(0);
						Attributes::ReadFailureCode::TypeInfo::DecodableType readFailureCode =
							static_cast<uint8_t>(0);
						Attributes::FailureInt32U::TypeInfo::DecodableType failureInt32U =
							static_cast<uint32_t>(0);
						Attributes::NullableBoolean::TypeInfo::DecodableType nullableBoolean;
						Attributes::NullableBitmap8::TypeInfo::DecodableType nullableBitmap8;
						Attributes::NullableBitmap16::TypeInfo::DecodableType nullableBitmap16;
						Attributes::NullableBitmap32::TypeInfo::DecodableType nullableBitmap32;
						Attributes::NullableBitmap64::TypeInfo::DecodableType nullableBitmap64;
						Attributes::NullableInt8u::TypeInfo::DecodableType nullableInt8u;
						Attributes::NullableInt16u::TypeInfo::DecodableType nullableInt16u;
						Attributes::NullableInt24u::TypeInfo::DecodableType nullableInt24u;
						Attributes::NullableInt32u::TypeInfo::DecodableType nullableInt32u;
						Attributes::NullableInt40u::TypeInfo::DecodableType nullableInt40u;
						Attributes::NullableInt48u::TypeInfo::DecodableType nullableInt48u;
						Attributes::NullableInt56u::TypeInfo::DecodableType nullableInt56u;
						Attributes::NullableInt64u::TypeInfo::DecodableType nullableInt64u;
						Attributes::NullableInt8s::TypeInfo::DecodableType nullableInt8s;
						Attributes::NullableInt16s::TypeInfo::DecodableType nullableInt16s;
						Attributes::NullableInt24s::TypeInfo::DecodableType nullableInt24s;
						Attributes::NullableInt32s::TypeInfo::DecodableType nullableInt32s;
						Attributes::NullableInt40s::TypeInfo::DecodableType nullableInt40s;
						Attributes::NullableInt48s::TypeInfo::DecodableType nullableInt48s;
						Attributes::NullableInt56s::TypeInfo::DecodableType nullableInt56s;
						Attributes::NullableInt64s::TypeInfo::DecodableType nullableInt64s;
						Attributes::NullableEnum8::TypeInfo::DecodableType nullableEnum8;
						Attributes::NullableEnum16::TypeInfo::DecodableType nullableEnum16;
						Attributes::NullableFloatSingle::TypeInfo::DecodableType
							nullableFloatSingle;
						Attributes::NullableFloatDouble::TypeInfo::DecodableType
							nullableFloatDouble;
						Attributes::NullableOctetString::TypeInfo::DecodableType
							nullableOctetString;
						Attributes::NullableCharString::TypeInfo::DecodableType
							nullableCharString;
						Attributes::NullableEnumAttr::TypeInfo::DecodableType nullableEnumAttr;
						Attributes::NullableStruct::TypeInfo::DecodableType nullableStruct;
						Attributes::NullableRangeRestrictedInt8u::TypeInfo::DecodableType
							nullableRangeRestrictedInt8u;
						Attributes::NullableRangeRestrictedInt8s::TypeInfo::DecodableType
							nullableRangeRestrictedInt8s;
						Attributes::NullableRangeRestrictedInt16u::TypeInfo::DecodableType
							nullableRangeRestrictedInt16u;
						Attributes::NullableRangeRestrictedInt16s::TypeInfo::DecodableType
							nullableRangeRestrictedInt16s;
						Attributes::WriteOnlyInt8u::TypeInfo::DecodableType writeOnlyInt8u =
							static_cast<uint8_t>(0);
						Attributes::NullableGlobalEnum::TypeInfo::DecodableType
							nullableGlobalEnum;
						Attributes::NullableGlobalStruct::TypeInfo::DecodableType
							nullableGlobalStruct;
						Attributes::GeneratedCommandList::TypeInfo::DecodableType
							generatedCommandList;
						Attributes::AcceptedCommandList::TypeInfo::DecodableType
							acceptedCommandList;
						Attributes::AttributeList::TypeInfo::DecodableType attributeList;
						Attributes::FeatureMap::TypeInfo::DecodableType featureMap =
							static_cast<uint32_t>(0);
						Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision =
							static_cast<uint16_t>(0);
						Attributes::MeiInt8u::TypeInfo::DecodableType meiInt8u =
							static_cast<uint8_t>(0);
					};
				};
			} // namespace Attributes
		} // namespace UnitTesting
	} // namespace Clusters
} // namespace app
} // namespace chip
